프런트엔드 웹 잠금 교착 상태 감지: 리소스 잠금 주기 방지

            // Two asynchronous functions that acquire and release locks
async function operationA(resource1, resource2) {
  await acquireLock(resource1);
  try {
    await operationB(resource2, resource1); // Calls operationB, potentially waiting for resource2
  } finally {
    releaseLock(resource1);
  }
}

async function operationB(resource2, resource1) {
  await acquireLock(resource2);
  try {
    // Perform some operation
  } finally {
    releaseLock(resource2);
  }
}

// Simplified lock acquisition/release functions
const locks = {};

async function acquireLock(resource) {
  return new Promise((resolve) => {
    if (!locks[resource]) {
      locks[resource] = true;
      resolve();
    } else {
      // Wait until the resource is released
      const interval = setInterval(() => {
        if (!locks[resource]) {
          locks[resource] = true;
          clearInterval(interval);
          resolve();
        }
      }, 50); // Polling interval
    }
  });
}

function releaseLock(resource) {
  locks[resource] = false;
}

// Simulate a deadlock
async function simulateDeadlock() {
  await operationA('resource1', 'resource2');
  await operationB('resource2', 'resource1');
}

simulateDeadlock();

            

              
                Copy
              
            
          

            async function operationC(resource1, resource2) {
  let lock1Acquired = false;
  let lock2Acquired = false;
  try {
    lock1Acquired = await tryAcquireLock(resource1);
    if (!lock1Acquired) {
      return false; // Could not acquire lock1, abort
    }

    lock2Acquired = await tryAcquireLock(resource2);
    if (!lock2Acquired) {
      releaseLock(resource1);
      return false; // Could not acquire lock2, abort and release lock1
    }

    // Perform operation with both resources locked
    console.log('Both locks acquired successfully!');
    return true;

  } finally {
    if (lock1Acquired) {
      releaseLock(resource1);
    }
    if (lock2Acquired) {
      releaseLock(resource2);
    }
  }
}

async function tryAcquireLock(resource) {
    if (!locks[resource]) {
      locks[resource] = true;
      return true; // Lock acquired successfully
    } else {
      return false; // Lock is already held
    }
}

            

              
                Copy
              
            
          

            async function operationWithTimeout(resource, timeoutMs) {
  const controller = new AbortController();
  const timeoutId = setTimeout(() => {
    controller.abort(); // Signal cancellation after timeout
  }, timeoutMs);

  try {
    await acquireLock(resource, controller.signal);
    console.log('Lock acquired, performing operation...');
    // Simulate long-running operation
    await new Promise(resolve => setTimeout(resolve, 2000));

  } catch (error) {
    if (error.name === 'AbortError') {
      console.log('Operation cancelled due to timeout.');
    } else {
      console.error('Error during operation:', error);
    }
  } finally {
    clearTimeout(timeoutId);
    releaseLock(resource);
    console.log('Lock released.');
  }
}

async function acquireLock(resource, signal) {
  return new Promise((resolve, reject) => {
    if (locks[resource]) {
      const intervalId = setInterval(() => {
        if (!locks[resource]) {
            locks[resource] = true; //Attempt to acquire
            clearInterval(intervalId);
            resolve();
        }
      }, 50);

      signal.addEventListener('abort', () => {
        clearInterval(intervalId);
        reject(new Error('Aborted'));
      });

    } else {
      locks[resource] = true;
      resolve();
    }

  });
}

            

              
                Copy
              
            
          

            // Define a global order for resources
const resourceOrder = ['resourceA', 'resourceB', 'resourceC'];

async function operationWithOrderedLocks(resource1, resource2) {
  const index1 = resourceOrder.indexOf(resource1);
  const index2 = resourceOrder.indexOf(resource2);

  if (index1 === -1 || index2 === -1) {
    throw new Error('Invalid resource name.');
  }

  // Ensure locks are acquired in the correct order
  const firstResource = index1 < index2 ? resource1 : resource2;
  const secondResource = index1 < index2 ? resource2 : resource1;

  try {
    await acquireLock(firstResource);
    try {
      await acquireLock(secondResource);
      // Perform operation with both resources locked
      console.log(`Operation with ${firstResource} and ${secondResource}`);
    } finally {
      releaseLock(secondResource);
    }
  } finally {
    releaseLock(firstResource);
  }
}

            

              
                Copy
              
            
          

            // Simplified Resource Allocation Graph (Conceptual)
class ResourceAllocationGraph {
  constructor() {
    this.graph = {}; // { process: [resources held], resource: [processes waiting] }
  }

  addProcess(process) {
    this.graph[process] = {held: [], waitingFor: null};
  }

  addResource(resource) {
    if(!this.graph[resource]) {
      this.graph[resource] = []; //processes waiting for resource
    }
  }

  allocateResource(process, resource) {
    if (!this.graph[process]) this.addProcess(process);
    if (!this.graph[resource]) this.addResource(resource);

    if (this.graph[resource].length === 0) {
      this.graph[process].held.push(resource);
      this.graph[resource] = process;

    } else {
      this.graph[process].waitingFor = resource; //process is waiting for the resource
      this.graph[resource].push(process); //add process to queue waiting for this resource

    }
  }

  releaseResource(process, resource) {
    const index = this.graph[process].held.indexOf(resource);
    if (index > -1) {
      this.graph[process].held.splice(index, 1);

      this.graph[resource] = null;

    }
  }

  detectCycle() {
    // Implement cycle detection algorithm (e.g., Depth-First Search)
    // This is a simplified example and requires a proper DFS implementation
    // to accurately detect cycles in the graph.
    // The idea is to traverse the graph and look for back edges.

    let visited = new Set();
    let recursionStack = new Set();

    for (const process in this.graph) {
      if (!visited.has(process)) {
        if (this.dfs(process, visited, recursionStack)) {
          return true; // Cycle detected
        }
      }
    }

    return false; // No cycle detected
  }

  dfs(process, visited, recursionStack) {
      visited.add(process);
      recursionStack.add(process);

      if (this.graph[process].waitingFor) {
          let resourceWaitingFor = this.graph[process].waitingFor;
          if(this.graph[resourceWaitingFor] !== null) { //Resource is in use
            let waitingProcess = this.graph[resourceWaitingFor];
            if(recursionStack.has(waitingProcess)) {
              return true; //Cycle Detected
            }

            if(visited.has(waitingProcess) == false) {
              if(this.dfs(waitingProcess, visited, recursionStack)){n                return true;
              }
            }
          }

      }

      recursionStack.delete(process);
      return false;
  }
}

// Example Usage (Conceptual)
const graph = new ResourceAllocationGraph();
graph.addProcess('processA');
graph.addProcess('processB');
graph.addResource('resource1');
graph.addResource('resource2');

graph.allocateResource('processA', 'resource1');
graph.allocateResource('processB', 'resource2');
graph.allocateResource('processA', 'resource2'); // processA now waits for resource2
graph.allocateResource('processB', 'resource1'); // processB now waits for resource1

if (graph.detectCycle()) {
  console.log('Deadlock detected!');
} else {
  console.log('No deadlock detected.');
}

            

              
                Copy
              
            
          

            //Install async-mutex via npm
//npm install async-mutex

import { Mutex } from 'async-mutex';

const mutex1 = new Mutex();
const mutex2 = new Mutex();

async function operationWithMutex(resource1, resource2) {
  const release1 = await mutex1.acquire();
  try {
    const release2 = await mutex2.acquire();
    try {
      // Perform operations with resource1 and resource2
      console.log(`Operation with ${resource1} and ${resource2}`);
    } finally {
      release2(); // Release mutex2
    }
  } finally {
    release1(); // Release mutex1
  }
}

            

              
                Copy